home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_itertools.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  38KB  |  1,047 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. import unittest
  5. from test import test_support
  6. from itertools import *
  7. from weakref import proxy
  8. import sys
  9. import operator
  10. import random
  11.  
  12. def onearg(x):
  13.     '''Test function of one argument'''
  14.     return 2 * x
  15.  
  16.  
  17. def errfunc(*args):
  18.     '''Test function that raises an error'''
  19.     raise ValueError
  20.  
  21.  
  22. def gen3():
  23.     '''Non-restartable source sequence'''
  24.     for i in (0, 1, 2):
  25.         yield i
  26.     
  27.  
  28.  
  29. def isEven(x):
  30.     '''Test predicate'''
  31.     return x % 2 == 0
  32.  
  33.  
  34. def isOdd(x):
  35.     '''Test predicate'''
  36.     return x % 2 == 1
  37.  
  38.  
  39. class StopNow:
  40.     '''Class emulating an empty iterable.'''
  41.     
  42.     def __iter__(self):
  43.         return self
  44.  
  45.     
  46.     def next(self):
  47.         raise StopIteration
  48.  
  49.  
  50.  
  51. def take(n, seq):
  52.     '''Convenience function for partially consuming a long of infinite iterable'''
  53.     return list(islice(seq, n))
  54.  
  55.  
  56. class TestBasicOps(unittest.TestCase):
  57.     
  58.     def test_chain(self):
  59.         self.assertEqual(list(chain('abc', 'def')), list('abcdef'))
  60.         self.assertEqual(list(chain('abc')), list('abc'))
  61.         self.assertEqual(list(chain('')), [])
  62.         self.assertEqual(take(4, chain('abc', 'def')), list('abcd'))
  63.         self.assertRaises(TypeError, chain, 2, 3)
  64.  
  65.     
  66.     def test_count(self):
  67.         self.assertEqual(zip('abc', count()), [
  68.             ('a', 0),
  69.             ('b', 1),
  70.             ('c', 2)])
  71.         self.assertEqual(zip('abc', count(3)), [
  72.             ('a', 3),
  73.             ('b', 4),
  74.             ('c', 5)])
  75.         self.assertEqual(take(2, zip('abc', count(3))), [
  76.             ('a', 3),
  77.             ('b', 4)])
  78.         self.assertRaises(TypeError, count, 2, 3)
  79.         self.assertRaises(TypeError, count, 'a')
  80.         c = count(sys.maxint - 2)
  81.         c.next()
  82.         c.next()
  83.         c.next()
  84.         c.next()
  85.         c.next()
  86.         c = count(3)
  87.         self.assertEqual(repr(c), 'count(3)')
  88.         c.next()
  89.         self.assertEqual(repr(c), 'count(4)')
  90.  
  91.     
  92.     def test_cycle(self):
  93.         self.assertEqual(take(10, cycle('abc')), list('abcabcabca'))
  94.         self.assertEqual(list(cycle('')), [])
  95.         self.assertRaises(TypeError, cycle)
  96.         self.assertRaises(TypeError, cycle, 5)
  97.         self.assertEqual(list(islice(cycle(gen3()), 10)), [
  98.             0,
  99.             1,
  100.             2,
  101.             0,
  102.             1,
  103.             2,
  104.             0,
  105.             1,
  106.             2,
  107.             0])
  108.  
  109.     
  110.     def test_groupby(self):
  111.         self.assertEqual([], list(groupby([])))
  112.         self.assertEqual([], list(groupby([], key = id)))
  113.         self.assertRaises(TypeError, list, groupby('abc', []))
  114.         self.assertRaises(TypeError, groupby, None)
  115.         self.assertRaises(TypeError, groupby, 'abc', (lambda x: x), 10)
  116.         s = [
  117.             (0, 10, 20),
  118.             (0, 11, 21),
  119.             (0, 12, 21),
  120.             (1, 13, 21),
  121.             (1, 14, 22),
  122.             (2, 15, 22),
  123.             (3, 16, 23),
  124.             (3, 17, 23)]
  125.         dup = []
  126.         for k, g in groupby(s, (lambda r: r[0])):
  127.             for elem in g:
  128.                 self.assertEqual(k, elem[0])
  129.                 dup.append(elem)
  130.             
  131.         
  132.         self.assertEqual(s, dup)
  133.         dup = []
  134.         for k, g in groupby(s, (lambda r: r[0])):
  135.             for ik, ig in groupby(g, (lambda r: r[2])):
  136.                 for elem in ig:
  137.                     self.assertEqual(k, elem[0])
  138.                     self.assertEqual(ik, elem[2])
  139.                     dup.append(elem)
  140.                 
  141.             
  142.         
  143.         self.assertEqual(s, dup)
  144.         keys = [ k for k, g in groupby(s, (lambda r: r[0])) ]
  145.         expectedkeys = []([ r[0] for r in s ])
  146.         self.assertEqual(set(keys), expectedkeys)
  147.         self.assertEqual(len(keys), len(expectedkeys))
  148.         s = 'abracadabra'
  149.         r = [ k for k, g in groupby(sorted(s)) ]
  150.         self.assertEqual(r, [
  151.             'a',
  152.             'b',
  153.             'c',
  154.             'd',
  155.             'r'])
  156.         r = _[1]
  157.         self.assertEqual(r, [
  158.             'a',
  159.             'b',
  160.             'r'])
  161.         r = [ (len(list(g)), k) for k, g in groupby(sorted(s)) ]
  162.         self.assertEqual(r, [
  163.             (5, 'a'),
  164.             (2, 'b'),
  165.             (1, 'c'),
  166.             (1, 'd'),
  167.             (2, 'r')])
  168.         r = []([ (len(list(g)), k) for k, g in groupby(sorted(s)) ], reverse = True)[:3]
  169.         self.assertEqual(r, [
  170.             (5, 'a'),
  171.             (2, 'r'),
  172.             (2, 'b')])
  173.         
  174.         class ExpectedError(Exception):
  175.             pass
  176.  
  177.         
  178.         def delayed_raise(n = 0):
  179.             for i in range(n):
  180.                 yield 'yo'
  181.             
  182.             raise ExpectedError
  183.  
  184.         
  185.         def gulp(iterable, keyp = None, func = list):
  186.             return [ func(g) for k, g in groupby(iterable, keyp) ]
  187.  
  188.         self.assertRaises(ExpectedError, gulp, delayed_raise(0))
  189.         self.assertRaises(ExpectedError, gulp, delayed_raise(1))
  190.         
  191.         class DummyCmp:
  192.             
  193.             def __cmp__(self, dst):
  194.                 raise ExpectedError
  195.  
  196.  
  197.         s = [
  198.             DummyCmp(),
  199.             DummyCmp(),
  200.             None]
  201.         self.assertRaises(ExpectedError, gulp, s, func = id)
  202.         self.assertRaises(ExpectedError, gulp, s)
  203.         
  204.         def keyfunc(obj):
  205.             if keyfunc.skip > 0:
  206.                 keyfunc.skip -= 1
  207.                 return obj
  208.             else:
  209.                 raise ExpectedError
  210.  
  211.         keyfunc.skip = 0
  212.         self.assertRaises(ExpectedError, gulp, [
  213.             None], keyfunc)
  214.         keyfunc.skip = 1
  215.         self.assertRaises(ExpectedError, gulp, [
  216.             None,
  217.             None], keyfunc)
  218.  
  219.     
  220.     def test_ifilter(self):
  221.         self.assertEqual(list(ifilter(isEven, range(6))), [
  222.             0,
  223.             2,
  224.             4])
  225.         self.assertEqual(list(ifilter(None, [
  226.             0,
  227.             1,
  228.             0,
  229.             2,
  230.             0])), [
  231.             1,
  232.             2])
  233.         self.assertEqual(take(4, ifilter(isEven, count())), [
  234.             0,
  235.             2,
  236.             4,
  237.             6])
  238.         self.assertRaises(TypeError, ifilter)
  239.         self.assertRaises(TypeError, ifilter, (lambda x: x))
  240.         self.assertRaises(TypeError, ifilter, (lambda x: x), range(6), 7)
  241.         self.assertRaises(TypeError, ifilter, isEven, 3)
  242.         self.assertRaises(TypeError, ifilter(range(6), range(6)).next)
  243.  
  244.     
  245.     def test_ifilterfalse(self):
  246.         self.assertEqual(list(ifilterfalse(isEven, range(6))), [
  247.             1,
  248.             3,
  249.             5])
  250.         self.assertEqual(list(ifilterfalse(None, [
  251.             0,
  252.             1,
  253.             0,
  254.             2,
  255.             0])), [
  256.             0,
  257.             0,
  258.             0])
  259.         self.assertEqual(take(4, ifilterfalse(isEven, count())), [
  260.             1,
  261.             3,
  262.             5,
  263.             7])
  264.         self.assertRaises(TypeError, ifilterfalse)
  265.         self.assertRaises(TypeError, ifilterfalse, (lambda x: x))
  266.         self.assertRaises(TypeError, ifilterfalse, (lambda x: x), range(6), 7)
  267.         self.assertRaises(TypeError, ifilterfalse, isEven, 3)
  268.         self.assertRaises(TypeError, ifilterfalse(range(6), range(6)).next)
  269.  
  270.     
  271.     def test_izip(self):
  272.         ans = [ (x, y) for x, y in izip('abc', count()) ]
  273.         self.assertEqual(ans, [
  274.             ('a', 0),
  275.             ('b', 1),
  276.             ('c', 2)])
  277.         self.assertEqual(list(izip('abc', range(6))), zip('abc', range(6)))
  278.         self.assertEqual(list(izip('abcdef', range(3))), zip('abcdef', range(3)))
  279.         self.assertEqual(take(3, izip('abcdef', count())), zip('abcdef', range(3)))
  280.         self.assertEqual(list(izip('abcdef')), zip('abcdef'))
  281.         self.assertEqual(list(izip()), zip())
  282.         self.assertRaises(TypeError, izip, 3)
  283.         self.assertRaises(TypeError, izip, range(3), 3)
  284.         []([ tuple(list(pair)) for pair in izip('abc', 'def') ], zip('abc', 'def'))
  285.         []([ pair for pair in izip('abc', 'def') ], zip('abc', 'def'))
  286.         ids = map(id, izip('abc', 'def'))
  287.         self.assertEqual(min(ids), max(ids))
  288.         ids = map(id, list(izip('abc', 'def')))
  289.         self.assertEqual(len(dict.fromkeys(ids)), len(ids))
  290.  
  291.     
  292.     def test_repeat(self):
  293.         self.assertEqual(zip(xrange(3), repeat('a')), [
  294.             (0, 'a'),
  295.             (1, 'a'),
  296.             (2, 'a')])
  297.         self.assertEqual(list(repeat('a', 3)), [
  298.             'a',
  299.             'a',
  300.             'a'])
  301.         self.assertEqual(take(3, repeat('a')), [
  302.             'a',
  303.             'a',
  304.             'a'])
  305.         self.assertEqual(list(repeat('a', 0)), [])
  306.         self.assertEqual(list(repeat('a', -3)), [])
  307.         self.assertRaises(TypeError, repeat)
  308.         self.assertRaises(TypeError, repeat, None, 3, 4)
  309.         self.assertRaises(TypeError, repeat, None, 'a')
  310.         r = repeat(1 + (0.0+0.0j))
  311.         self.assertEqual(repr(r), 'repeat((1+0j))')
  312.         r = repeat(1 + (0.0+0.0j), 5)
  313.         self.assertEqual(repr(r), 'repeat((1+0j), 5)')
  314.         list(r)
  315.         self.assertEqual(repr(r), 'repeat((1+0j), 0)')
  316.  
  317.     
  318.     def test_imap(self):
  319.         self.assertEqual(list(imap(operator.pow, range(3), range(1, 7))), [
  320.             0 ** 1,
  321.             1 ** 2,
  322.             2 ** 3])
  323.         self.assertEqual(list(imap(None, 'abc', range(5))), [
  324.             ('a', 0),
  325.             ('b', 1),
  326.             ('c', 2)])
  327.         self.assertEqual(list(imap(None, 'abc', count())), [
  328.             ('a', 0),
  329.             ('b', 1),
  330.             ('c', 2)])
  331.         self.assertEqual(take(2, imap(None, 'abc', count())), [
  332.             ('a', 0),
  333.             ('b', 1)])
  334.         self.assertEqual(list(imap(operator.pow, [])), [])
  335.         self.assertRaises(TypeError, imap)
  336.         self.assertRaises(TypeError, imap, operator.neg)
  337.         self.assertRaises(TypeError, imap(10, range(5)).next)
  338.         self.assertRaises(ValueError, imap(errfunc, [
  339.             4], [
  340.             5]).next)
  341.         self.assertRaises(TypeError, imap(onearg, [
  342.             4], [
  343.             5]).next)
  344.  
  345.     
  346.     def test_starmap(self):
  347.         self.assertEqual(list(starmap(operator.pow, zip(range(3), range(1, 7)))), [
  348.             0 ** 1,
  349.             1 ** 2,
  350.             2 ** 3])
  351.         self.assertEqual(take(3, starmap(operator.pow, izip(count(), count(1)))), [
  352.             0 ** 1,
  353.             1 ** 2,
  354.             2 ** 3])
  355.         self.assertEqual(list(starmap(operator.pow, [])), [])
  356.         self.assertRaises(TypeError, list, starmap(operator.pow, [
  357.             [
  358.                 4,
  359.                 5]]))
  360.         self.assertRaises(TypeError, starmap)
  361.         self.assertRaises(TypeError, starmap, operator.pow, [
  362.             (4, 5)], 'extra')
  363.         self.assertRaises(TypeError, starmap(10, [
  364.             (4, 5)]).next)
  365.         self.assertRaises(ValueError, starmap(errfunc, [
  366.             (4, 5)]).next)
  367.         self.assertRaises(TypeError, starmap(onearg, [
  368.             (4, 5)]).next)
  369.  
  370.     
  371.     def test_islice(self):
  372.         for args in [
  373.             (10, 20, 3),
  374.             (10, 3, 20),
  375.             (10, 20),
  376.             (10, 3),
  377.             (20,)]:
  378.             self.assertEqual(list(islice(xrange(100), *args)), range(*args))
  379.         
  380.         for args, tgtargs in [
  381.             ((10, 110, 3), (10, 100, 3)),
  382.             ((10, 110), (10, 100)),
  383.             ((110,), (100,))]:
  384.             self.assertEqual(list(islice(xrange(100), *args)), range(*tgtargs))
  385.         
  386.         self.assertEqual(list(islice(xrange(10), None)), range(10))
  387.         self.assertEqual(list(islice(xrange(10), 2, None)), range(2, 10))
  388.         self.assertEqual(list(islice(xrange(10), 1, None, 2)), range(1, 10, 2))
  389.         self.assertRaises(TypeError, islice, xrange(10))
  390.         self.assertRaises(TypeError, islice, xrange(10), 1, 2, 3, 4)
  391.         self.assertRaises(ValueError, islice, xrange(10), -5, 10, 1)
  392.         self.assertRaises(ValueError, islice, xrange(10), 1, -5, -1)
  393.         self.assertRaises(ValueError, islice, xrange(10), 1, 10, -1)
  394.         self.assertRaises(ValueError, islice, xrange(10), 1, 10, 0)
  395.         self.assertRaises(ValueError, islice, xrange(10), 'a')
  396.         self.assertRaises(ValueError, islice, xrange(10), 'a', 1)
  397.         self.assertRaises(ValueError, islice, xrange(10), 1, 'a')
  398.         self.assertRaises(ValueError, islice, xrange(10), 'a', 1, 1)
  399.         self.assertRaises(ValueError, islice, xrange(10), 1, 'a', 1)
  400.         self.assertEqual(len(list(islice(count(), 1, 10, sys.maxint))), 1)
  401.  
  402.     
  403.     def test_takewhile(self):
  404.         data = [
  405.             1,
  406.             3,
  407.             5,
  408.             20,
  409.             2,
  410.             4,
  411.             6,
  412.             8]
  413.         
  414.         underten = lambda x: x < 10
  415.         self.assertEqual(list(takewhile(underten, data)), [
  416.             1,
  417.             3,
  418.             5])
  419.         self.assertEqual(list(takewhile(underten, [])), [])
  420.         self.assertRaises(TypeError, takewhile)
  421.         self.assertRaises(TypeError, takewhile, operator.pow)
  422.         self.assertRaises(TypeError, takewhile, operator.pow, [
  423.             (4, 5)], 'extra')
  424.         self.assertRaises(TypeError, takewhile(10, [
  425.             (4, 5)]).next)
  426.         self.assertRaises(ValueError, takewhile(errfunc, [
  427.             (4, 5)]).next)
  428.         t = takewhile(bool, [
  429.             1,
  430.             1,
  431.             1,
  432.             0,
  433.             0,
  434.             0])
  435.         self.assertEqual(list(t), [
  436.             1,
  437.             1,
  438.             1])
  439.         self.assertRaises(StopIteration, t.next)
  440.  
  441.     
  442.     def test_dropwhile(self):
  443.         data = [
  444.             1,
  445.             3,
  446.             5,
  447.             20,
  448.             2,
  449.             4,
  450.             6,
  451.             8]
  452.         
  453.         underten = lambda x: x < 10
  454.         self.assertEqual(list(dropwhile(underten, data)), [
  455.             20,
  456.             2,
  457.             4,
  458.             6,
  459.             8])
  460.         self.assertEqual(list(dropwhile(underten, [])), [])
  461.         self.assertRaises(TypeError, dropwhile)
  462.         self.assertRaises(TypeError, dropwhile, operator.pow)
  463.         self.assertRaises(TypeError, dropwhile, operator.pow, [
  464.             (4, 5)], 'extra')
  465.         self.assertRaises(TypeError, dropwhile(10, [
  466.             (4, 5)]).next)
  467.         self.assertRaises(ValueError, dropwhile(errfunc, [
  468.             (4, 5)]).next)
  469.  
  470.     
  471.     def test_tee(self):
  472.         n = 200
  473.         
  474.         def irange(n):
  475.             for i in xrange(n):
  476.                 yield i
  477.             
  478.  
  479.         (a, b) = tee([])
  480.         self.assertEqual(list(a), [])
  481.         self.assertEqual(list(b), [])
  482.         (a, b) = tee(irange(n))
  483.         self.assertEqual(zip(a, b), zip(range(n), range(n)))
  484.         (a, b) = tee(irange(n))
  485.         self.assertEqual(list(a), range(n))
  486.         self.assertEqual(list(b), range(n))
  487.         (a, b) = tee(irange(n))
  488.         for i in xrange(100):
  489.             self.assertEqual(a.next(), i)
  490.         
  491.         del a
  492.         self.assertEqual(list(b), range(n))
  493.         (a, b) = tee(irange(n))
  494.         for i in xrange(100):
  495.             self.assertEqual(a.next(), i)
  496.         
  497.         del b
  498.         self.assertEqual(list(a), range(100, n))
  499.         for j in xrange(5):
  500.             order = [
  501.                 0] * n + [
  502.                 1] * n
  503.             random.shuffle(order)
  504.             lists = ([], [])
  505.             its = tee(irange(n))
  506.             for i in order:
  507.                 value = its[i].next()
  508.                 lists[i].append(value)
  509.             
  510.             self.assertEqual(lists[0], range(n))
  511.             self.assertEqual(lists[1], range(n))
  512.         
  513.         self.assertRaises(TypeError, tee)
  514.         self.assertRaises(TypeError, tee, 3)
  515.         self.assertRaises(TypeError, tee, [
  516.             1,
  517.             2], 'x')
  518.         self.assertRaises(TypeError, tee, [
  519.             1,
  520.             2], 3, 'x')
  521.         (a, b) = tee('abc')
  522.         c = type(a)('def')
  523.         self.assertEqual(list(c), list('def'))
  524.         (a, b, c) = tee(xrange(2000), 3)
  525.         for i in xrange(100):
  526.             self.assertEqual(a.next(), i)
  527.         
  528.         self.assertEqual(list(b), range(2000))
  529.         self.assertEqual([
  530.             c.next(),
  531.             c.next()], range(2))
  532.         self.assertEqual(list(a), range(100, 2000))
  533.         self.assertEqual(list(c), range(2, 2000))
  534.         self.assertRaises(TypeError, tee, 'abc', 'invalid')
  535.         for n in xrange(5):
  536.             result = tee('abc', n)
  537.             self.assertEqual(type(result), tuple)
  538.             self.assertEqual(len(result), n)
  539.             self.assertEqual(map(list, result), [
  540.                 list('abc')] * n)
  541.         
  542.         (a, b) = tee('abc')
  543.         (c, d) = tee(a)
  544.         self.assert_(a is c)
  545.         (t1, t2) = tee('abc')
  546.         tnew = type(t1)
  547.         self.assertRaises(TypeError, tnew)
  548.         self.assertRaises(TypeError, tnew, 10)
  549.         t3 = tnew(t1)
  550.         None(self.assert_ if list(t2) == list(t2) and list(t3) == list(t3) else list(t3) == list('abc'))
  551.         (a, b) = tee(xrange(10))
  552.         p = proxy(a)
  553.         self.assertEqual(getattr(p, '__class__'), type(b))
  554.         del a
  555.         self.assertRaises(ReferenceError, getattr, p, '__class__')
  556.  
  557.     
  558.     def test_StopIteration(self):
  559.         self.assertRaises(StopIteration, izip().next)
  560.         for f in (chain, cycle, izip, groupby):
  561.             self.assertRaises(StopIteration, f([]).next)
  562.             self.assertRaises(StopIteration, f(StopNow()).next)
  563.         
  564.         self.assertRaises(StopIteration, islice([], None).next)
  565.         self.assertRaises(StopIteration, islice(StopNow(), None).next)
  566.         (p, q) = tee([])
  567.         self.assertRaises(StopIteration, p.next)
  568.         self.assertRaises(StopIteration, q.next)
  569.         (p, q) = tee(StopNow())
  570.         self.assertRaises(StopIteration, p.next)
  571.         self.assertRaises(StopIteration, q.next)
  572.         self.assertRaises(StopIteration, repeat(None, 0).next)
  573.         for f in (ifilter, ifilterfalse, imap, takewhile, dropwhile, starmap):
  574.             self.assertRaises(StopIteration, f((lambda x: x), []).next)
  575.             self.assertRaises(StopIteration, f((lambda x: x), StopNow()).next)
  576.         
  577.  
  578.  
  579.  
  580. class TestGC(unittest.TestCase):
  581.     
  582.     def makecycle(self, iterator, container):
  583.         container.append(iterator)
  584.         iterator.next()
  585.         del container
  586.         del iterator
  587.  
  588.     
  589.     def test_chain(self):
  590.         a = []
  591.         self.makecycle(chain(a), a)
  592.  
  593.     
  594.     def test_cycle(self):
  595.         a = []
  596.         self.makecycle(cycle([
  597.             a] * 2), a)
  598.  
  599.     
  600.     def test_dropwhile(self):
  601.         a = []
  602.         self.makecycle(dropwhile(bool, [
  603.             0,
  604.             a,
  605.             a]), a)
  606.  
  607.     
  608.     def test_groupby(self):
  609.         a = []
  610.         self.makecycle(groupby([
  611.             a] * 2, (lambda x: x)), a)
  612.  
  613.     
  614.     def test_ifilter(self):
  615.         a = []
  616.         self.makecycle(ifilter((lambda x: True), [
  617.             a] * 2), a)
  618.  
  619.     
  620.     def test_ifilterfalse(self):
  621.         a = []
  622.         self.makecycle(ifilterfalse((lambda x: False), a), a)
  623.  
  624.     
  625.     def test_izip(self):
  626.         a = []
  627.         self.makecycle(izip([
  628.             a] * 2, [
  629.             a] * 3), a)
  630.  
  631.     
  632.     def test_imap(self):
  633.         a = []
  634.         self.makecycle(imap((lambda x: x), [
  635.             a] * 2), a)
  636.  
  637.     
  638.     def test_islice(self):
  639.         a = []
  640.         self.makecycle(islice([
  641.             a] * 2, None), a)
  642.  
  643.     
  644.     def test_repeat(self):
  645.         a = []
  646.         self.makecycle(repeat(a), a)
  647.  
  648.     
  649.     def test_starmap(self):
  650.         a = []
  651.         self.makecycle(starmap((lambda : t), [
  652.             (a, a)] * 2), a)
  653.  
  654.     
  655.     def test_takewhile(self):
  656.         a = []
  657.         self.makecycle(takewhile(bool, [
  658.             1,
  659.             0,
  660.             a,
  661.             a]), a)
  662.  
  663.  
  664.  
  665. def R(seqn):
  666.     '''Regular generator'''
  667.     for i in seqn:
  668.         yield i
  669.     
  670.  
  671.  
  672. class G:
  673.     '''Sequence using __getitem__'''
  674.     
  675.     def __init__(self, seqn):
  676.         self.seqn = seqn
  677.  
  678.     
  679.     def __getitem__(self, i):
  680.         return self.seqn[i]
  681.  
  682.  
  683.  
  684. class I:
  685.     '''Sequence using iterator protocol'''
  686.     
  687.     def __init__(self, seqn):
  688.         self.seqn = seqn
  689.         self.i = 0
  690.  
  691.     
  692.     def __iter__(self):
  693.         return self
  694.  
  695.     
  696.     def next(self):
  697.         if self.i >= len(self.seqn):
  698.             raise StopIteration
  699.         
  700.         v = self.seqn[self.i]
  701.         self.i += 1
  702.         return v
  703.  
  704.  
  705.  
  706. class Ig:
  707.     '''Sequence using iterator protocol defined with a generator'''
  708.     
  709.     def __init__(self, seqn):
  710.         self.seqn = seqn
  711.         self.i = 0
  712.  
  713.     
  714.     def __iter__(self):
  715.         for val in self.seqn:
  716.             yield val
  717.         
  718.  
  719.  
  720.  
  721. class X:
  722.     '''Missing __getitem__ and __iter__'''
  723.     
  724.     def __init__(self, seqn):
  725.         self.seqn = seqn
  726.         self.i = 0
  727.  
  728.     
  729.     def next(self):
  730.         if self.i >= len(self.seqn):
  731.             raise StopIteration
  732.         
  733.         v = self.seqn[self.i]
  734.         self.i += 1
  735.         return v
  736.  
  737.  
  738.  
  739. class N:
  740.     '''Iterator missing next()'''
  741.     
  742.     def __init__(self, seqn):
  743.         self.seqn = seqn
  744.         self.i = 0
  745.  
  746.     
  747.     def __iter__(self):
  748.         return self
  749.  
  750.  
  751.  
  752. class E:
  753.     '''Test propagation of exceptions'''
  754.     
  755.     def __init__(self, seqn):
  756.         self.seqn = seqn
  757.         self.i = 0
  758.  
  759.     
  760.     def __iter__(self):
  761.         return self
  762.  
  763.     
  764.     def next(self):
  765.         3 // 0
  766.  
  767.  
  768.  
  769. class S:
  770.     '''Test immediate stop'''
  771.     
  772.     def __init__(self, seqn):
  773.         pass
  774.  
  775.     
  776.     def __iter__(self):
  777.         return self
  778.  
  779.     
  780.     def next(self):
  781.         raise StopIteration
  782.  
  783.  
  784.  
  785. def L(seqn):
  786.     '''Test multiple tiers of iterators'''
  787.     return chain(imap((lambda x: x), R(Ig(G(seqn)))))
  788.  
  789.  
  790. class TestVariousIteratorArgs(unittest.TestCase):
  791.     
  792.     def test_chain(self):
  793.         for s in ('123', '', range(1000), ('do', 1.2), xrange(2000, 2200, 5)):
  794.             for g in (G, I, Ig, S, L, R):
  795.                 self.assertEqual(list(chain(g(s))), list(g(s)))
  796.                 self.assertEqual(list(chain(g(s), g(s))), list(g(s)) + list(g(s)))
  797.             
  798.             self.assertRaises(TypeError, chain, X(s))
  799.             self.assertRaises(TypeError, list, chain(N(s)))
  800.             self.assertRaises(ZeroDivisionError, list, chain(E(s)))
  801.         
  802.  
  803.     
  804.     def test_cycle(self):
  805.         for s in ('123', '', range(1000), ('do', 1.2), xrange(2000, 2200, 5)):
  806.             for g in (G, I, Ig, S, L, R):
  807.                 tgtlen = len(s) * 3
  808.                 expected = list(g(s)) * 3
  809.                 actual = list(islice(cycle(g(s)), tgtlen))
  810.                 self.assertEqual(actual, expected)
  811.             
  812.             self.assertRaises(TypeError, cycle, X(s))
  813.             self.assertRaises(TypeError, list, cycle(N(s)))
  814.             self.assertRaises(ZeroDivisionError, list, cycle(E(s)))
  815.         
  816.  
  817.     
  818.     def test_groupby(self):
  819.         for s in (range(10), range(0), range(1000), (7, 11), xrange(2000, 2200, 5)):
  820.             for g in (G, I, Ig, S, L, R):
  821.                 []([ k for k, sb in groupby(g(s)) ], list(g(s)))
  822.             
  823.             self.assertRaises(TypeError, groupby, X(s))
  824.             self.assertRaises(TypeError, list, groupby(N(s)))
  825.             self.assertRaises(ZeroDivisionError, list, groupby(E(s)))
  826.         
  827.  
  828.     
  829.     def test_ifilter(self):
  830.         for s in (range(10), range(0), range(1000), (7, 11), xrange(2000, 2200, 5)):
  831.             for g in (G, I, Ig, S, L, R):
  832.                 self.assertEqual(list(ifilter(isEven, g(s))), filter(isEven, g(s)))
  833.             
  834.             self.assertRaises(TypeError, ifilter, isEven, X(s))
  835.             self.assertRaises(TypeError, list, ifilter(isEven, N(s)))
  836.             self.assertRaises(ZeroDivisionError, list, ifilter(isEven, E(s)))
  837.         
  838.  
  839.     
  840.     def test_ifilterfalse(self):
  841.         for s in (range(10), range(0), range(1000), (7, 11), xrange(2000, 2200, 5)):
  842.             for g in (G, I, Ig, S, L, R):
  843.                 self.assertEqual(list(ifilterfalse(isEven, g(s))), filter(isOdd, g(s)))
  844.             
  845.             self.assertRaises(TypeError, ifilterfalse, isEven, X(s))
  846.             self.assertRaises(TypeError, list, ifilterfalse(isEven, N(s)))
  847.             self.assertRaises(ZeroDivisionError, list, ifilterfalse(isEven, E(s)))
  848.         
  849.  
  850.     
  851.     def test_izip(self):
  852.         for s in ('123', '', range(1000), ('do', 1.2), xrange(2000, 2200, 5)):
  853.             for g in (G, I, Ig, S, L, R):
  854.                 self.assertEqual(list(izip(g(s))), zip(g(s)))
  855.                 self.assertEqual(list(izip(g(s), g(s))), zip(g(s), g(s)))
  856.             
  857.             self.assertRaises(TypeError, izip, X(s))
  858.             self.assertRaises(TypeError, list, izip(N(s)))
  859.             self.assertRaises(ZeroDivisionError, list, izip(E(s)))
  860.         
  861.  
  862.     
  863.     def test_imap(self):
  864.         for s in (range(10), range(0), range(100), (7, 11), xrange(20, 50, 5)):
  865.             for g in (G, I, Ig, S, L, R):
  866.                 self.assertEqual(list(imap(onearg, g(s))), map(onearg, g(s)))
  867.                 self.assertEqual(list(imap(operator.pow, g(s), g(s))), map(operator.pow, g(s), g(s)))
  868.             
  869.             self.assertRaises(TypeError, imap, onearg, X(s))
  870.             self.assertRaises(TypeError, list, imap(onearg, N(s)))
  871.             self.assertRaises(ZeroDivisionError, list, imap(onearg, E(s)))
  872.         
  873.  
  874.     
  875.     def test_islice(self):
  876.         for s in ('12345', '', range(1000), ('do', 1.2), xrange(2000, 2200, 5)):
  877.             for g in (G, I, Ig, S, L, R):
  878.                 self.assertEqual(list(islice(g(s), 1, None, 2)), list(g(s))[1::2])
  879.             
  880.             self.assertRaises(TypeError, islice, X(s), 10)
  881.             self.assertRaises(TypeError, list, islice(N(s), 10))
  882.             self.assertRaises(ZeroDivisionError, list, islice(E(s), 10))
  883.         
  884.  
  885.     
  886.     def test_starmap(self):
  887.         for s in (range(10), range(0), range(100), (7, 11), xrange(20, 50, 5)):
  888.             for g in (G, I, Ig, S, L, R):
  889.                 ss = zip(s, s)
  890.                 self.assertEqual(list(starmap(operator.pow, g(ss))), map(operator.pow, g(s), g(s)))
  891.             
  892.             self.assertRaises(TypeError, starmap, operator.pow, X(ss))
  893.             self.assertRaises(TypeError, list, starmap(operator.pow, N(ss)))
  894.             self.assertRaises(ZeroDivisionError, list, starmap(operator.pow, E(ss)))
  895.         
  896.  
  897.     
  898.     def test_takewhile(self):
  899.         for s in (range(10), range(0), range(1000), (7, 11), xrange(2000, 2200, 5)):
  900.             for g in (G, I, Ig, S, L, R):
  901.                 tgt = []
  902.                 for elem in g(s):
  903.                     if not isEven(elem):
  904.                         break
  905.                     
  906.                     tgt.append(elem)
  907.                 
  908.                 self.assertEqual(list(takewhile(isEven, g(s))), tgt)
  909.             
  910.             self.assertRaises(TypeError, takewhile, isEven, X(s))
  911.             self.assertRaises(TypeError, list, takewhile(isEven, N(s)))
  912.             self.assertRaises(ZeroDivisionError, list, takewhile(isEven, E(s)))
  913.         
  914.  
  915.     
  916.     def test_dropwhile(self):
  917.         for s in (range(10), range(0), range(1000), (7, 11), xrange(2000, 2200, 5)):
  918.             for g in (G, I, Ig, S, L, R):
  919.                 tgt = []
  920.                 for elem in g(s):
  921.                     if not tgt and isOdd(elem):
  922.                         continue
  923.                     
  924.                     tgt.append(elem)
  925.                 
  926.                 self.assertEqual(list(dropwhile(isOdd, g(s))), tgt)
  927.             
  928.             self.assertRaises(TypeError, dropwhile, isOdd, X(s))
  929.             self.assertRaises(TypeError, list, dropwhile(isOdd, N(s)))
  930.             self.assertRaises(ZeroDivisionError, list, dropwhile(isOdd, E(s)))
  931.         
  932.  
  933.     
  934.     def test_tee(self):
  935.         for s in ('123', '', range(1000), ('do', 1.2), xrange(2000, 2200, 5)):
  936.             for g in (G, I, Ig, S, L, R):
  937.                 (it1, it2) = tee(g(s))
  938.                 self.assertEqual(list(it1), list(g(s)))
  939.                 self.assertEqual(list(it2), list(g(s)))
  940.             
  941.             self.assertRaises(TypeError, tee, X(s))
  942.             self.assertRaises(TypeError, list, tee(N(s))[0])
  943.             self.assertRaises(ZeroDivisionError, list, tee(E(s))[0])
  944.         
  945.  
  946.  
  947.  
  948. class LengthTransparency(unittest.TestCase):
  949.     
  950.     def test_repeat(self):
  951.         self.assertEqual(len(repeat(None, 50)), 50)
  952.         self.assertRaises(TypeError, len, repeat(None))
  953.  
  954.  
  955.  
  956. class RegressionTests(unittest.TestCase):
  957.     
  958.     def test_sf_793826(self):
  959.         
  960.         def mutatingtuple(tuple1, f, tuple2):
  961.             
  962.             def g(value, first = [
  963.                 1]):
  964.                 if first:
  965.                     del first[:]
  966.                     f(z.next())
  967.                 
  968.                 return value
  969.  
  970.             items = list(tuple2)
  971.             items[1:1] = list(tuple1)
  972.             gen = imap(g, items)
  973.             z = izip(*[
  974.                 gen] * len(tuple1))
  975.             z.next()
  976.  
  977.         
  978.         def f(t):
  979.             global T
  980.             T = t
  981.             first[:] = list(T)
  982.  
  983.         first = []
  984.         mutatingtuple((1, 2, 3), f, (4, 5, 6))
  985.         second = list(T)
  986.         self.assertEqual(first, second)
  987.  
  988.     
  989.     def test_sf_950057(self):
  990.         
  991.         def gen1():
  992.             hist.append(0)
  993.             yield 1
  994.             hist.append(1)
  995.             raise AssertionError
  996.             hist.append(2)
  997.  
  998.         
  999.         def gen2(x):
  1000.             hist.append(3)
  1001.             yield 2
  1002.             hist.append(4)
  1003.             if x:
  1004.                 raise StopIteration
  1005.             
  1006.  
  1007.         hist = []
  1008.         self.assertRaises(AssertionError, list, chain(gen1(), gen2(False)))
  1009.         self.assertEqual(hist, [
  1010.             0,
  1011.             1])
  1012.         hist = []
  1013.         self.assertRaises(AssertionError, list, chain(gen1(), gen2(True)))
  1014.         self.assertEqual(hist, [
  1015.             0,
  1016.             1])
  1017.         hist = []
  1018.         self.assertRaises(AssertionError, list, cycle(gen1()))
  1019.         self.assertEqual(hist, [
  1020.             0,
  1021.             1])
  1022.  
  1023.  
  1024. libreftest = ' Doctest for examples in the library reference: libitertools.tex\n\n\n>>> amounts = [120.15, 764.05, 823.14]\n>>> for checknum, amount in izip(count(1200), amounts):\n...     print \'Check %d is for $%.2f\' % (checknum, amount)\n...\nCheck 1200 is for $120.15\nCheck 1201 is for $764.05\nCheck 1202 is for $823.14\n\n>>> import operator\n>>> for cube in imap(operator.pow, xrange(1,4), repeat(3)):\n...    print cube\n...\n1\n8\n27\n\n>>> reportlines = [\'EuroPython\', \'Roster\', \'\', \'alex\', \'\', \'laura\', \'\', \'martin\', \'\', \'walter\', \'\', \'samuele\']\n>>> for name in islice(reportlines, 3, None, 2):\n...    print name.title()\n...\nAlex\nLaura\nMartin\nWalter\nSamuele\n\n>>> from operator import itemgetter\n>>> d = dict(a=1, b=2, c=1, d=2, e=1, f=2, g=3)\n>>> di = sorted(d.iteritems(), key=itemgetter(1))\n>>> for k, g in groupby(di, itemgetter(1)):\n...     print k, map(itemgetter(0), g)\n...\n1 [\'a\', \'c\', \'e\']\n2 [\'b\', \'d\', \'f\']\n3 [\'g\']\n\n# Find runs of consecutive numbers using groupby.  The key to the solution\n# is differencing with a range so that consecutive numbers all appear in\n# same group.\n>>> data = [ 1,  4,5,6, 10, 15,16,17,18, 22, 25,26,27,28]\n>>> for k, g in groupby(enumerate(data), lambda (i,x):i-x):\n...     print map(operator.itemgetter(1), g)\n...\n[1]\n[4, 5, 6]\n[10]\n[15, 16, 17, 18]\n[22]\n[25, 26, 27, 28]\n\n>>> def take(n, seq):\n...     return list(islice(seq, n))\n\n>>> def enumerate(iterable):\n...     return izip(count(), iterable)\n\n>>> def tabulate(function):\n...     "Return function(0), function(1), ..."\n...     return imap(function, count())\n\n>>> def iteritems(mapping):\n...     return izip(mapping.iterkeys(), mapping.itervalues())\n\n>>> def nth(iterable, n):\n...     "Returns the nth item"\n...     return list(islice(iterable, n, n+1))\n\n>>> def all(seq, pred=bool):\n...     "Returns True if pred(x) is True for every element in the iterable"\n...     for elem in ifilterfalse(pred, seq):\n...         return False\n...     return True\n\n>>> def any(seq, pred=bool):\n...     "Returns True if pred(x) is True for at least one element in the iterable"\n...     for elem in ifilter(pred, seq):\n...         return True\n...     return False\n\n>>> def no(seq, pred=bool):\n...     "Returns True if pred(x) is False for every element in the iterable"\n...     for elem in ifilter(pred, seq):\n...         return False\n...     return True\n\n>>> def quantify(seq, pred=bool):\n...     "Count how many times the predicate is True in the sequence"\n...     return sum(imap(pred, seq))\n\n>>> def padnone(seq):\n...     "Returns the sequence elements and then returns None indefinitely"\n...     return chain(seq, repeat(None))\n\n>>> def ncycles(seq, n):\n...     "Returns the sequence elements n times"\n...     return chain(*repeat(seq, n))\n\n>>> def dotproduct(vec1, vec2):\n...     return sum(imap(operator.mul, vec1, vec2))\n\n>>> def flatten(listOfLists):\n...     return list(chain(*listOfLists))\n\n>>> def repeatfunc(func, times=None, *args):\n...     "Repeat calls to func with specified arguments."\n...     "   Example:  repeatfunc(random.random)"\n...     if times is None:\n...         return starmap(func, repeat(args))\n...     else:\n...         return starmap(func, repeat(args, times))\n\n>>> def pairwise(iterable):\n...     "s -> (s0,s1), (s1,s2), (s2, s3), ..."\n...     a, b = tee(iterable)\n...     try:\n...         b.next()\n...     except StopIteration:\n...         pass\n...     return izip(a, b)\n\nThis is not part of the examples but it tests to make sure the definitions\nperform as purported.\n\n>>> take(10, count())\n[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n\n>>> list(enumerate(\'abc\'))\n[(0, \'a\'), (1, \'b\'), (2, \'c\')]\n\n>>> list(islice(tabulate(lambda x: 2*x), 4))\n[0, 2, 4, 6]\n\n>>> nth(\'abcde\', 3)\n[\'d\']\n\n>>> all([2, 4, 6, 8], lambda x: x%2==0)\nTrue\n\n>>> all([2, 3, 6, 8], lambda x: x%2==0)\nFalse\n\n>>> any([2, 4, 6, 8], lambda x: x%2==0)\nTrue\n\n>>> any([1, 3, 5, 9], lambda x: x%2==0,)\nFalse\n\n>>> no([1, 3, 5, 9], lambda x: x%2==0)\nTrue\n\n>>> no([1, 2, 5, 9], lambda x: x%2==0)\nFalse\n\n>>> quantify(xrange(99), lambda x: x%2==0)\n50\n\n>>> a = [[1, 2, 3], [4, 5, 6]]\n>>> flatten(a)\n[1, 2, 3, 4, 5, 6]\n\n>>> list(repeatfunc(pow, 5, 2, 3))\n[8, 8, 8, 8, 8]\n\n>>> import random\n>>> take(5, imap(int, repeatfunc(random.random)))\n[0, 0, 0, 0, 0]\n\n>>> list(pairwise(\'abcd\'))\n[(\'a\', \'b\'), (\'b\', \'c\'), (\'c\', \'d\')]\n\n>>> list(pairwise([]))\n[]\n\n>>> list(pairwise(\'a\'))\n[]\n\n>>> list(islice(padnone(\'abc\'), 0, 6))\n[\'a\', \'b\', \'c\', None, None, None]\n\n>>> list(ncycles(\'abc\', 3))\n[\'a\', \'b\', \'c\', \'a\', \'b\', \'c\', \'a\', \'b\', \'c\']\n\n>>> dotproduct([1,2,3], [4,5,6])\n32\n\n'
  1025. __test__ = {
  1026.     'libreftest': libreftest }
  1027.  
  1028. def test_main(verbose = None):
  1029.     test_classes = (TestBasicOps, TestVariousIteratorArgs, TestGC, RegressionTests, LengthTransparency)
  1030.     test_support.run_unittest(*test_classes)
  1031.     if verbose and hasattr(sys, 'gettotalrefcount'):
  1032.         import gc as gc
  1033.         counts = [
  1034.             None] * 5
  1035.         for i in xrange(len(counts)):
  1036.             test_support.run_unittest(*test_classes)
  1037.             gc.collect()
  1038.             counts[i] = sys.gettotalrefcount()
  1039.         
  1040.         print counts
  1041.     
  1042.     test_support.run_doctest(sys.modules[__name__], verbose)
  1043.  
  1044. if __name__ == '__main__':
  1045.     test_main(verbose = True)
  1046.  
  1047.